﻿namespace NetFx.AST
{
  using System;
  using System.Text;
  using System.Collections;
  using System.Collections.Generic;

  using NetFx.SMIL.Definitions;
  using NetFx.SMIL.References;

  namespace CSharpBNF
  {

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ///
    /// 
    /// CSharp
    /// 
    ///
    ////////////////////////////////////////////////////////////////////////////////////////////////////////////

    #region Bnfs
    //compilation_unit
    //  : using_directive~, namespace_member_declaration~, attribute_section~,EOF,
    //  ; 
    //using_directive
    //  : using_alias_directive
    //  | using_namespace_directive
    //  ;

    //using_alias_directive
    //  : USING IDENTIFIER ASSIGN namespace_or_type_name SEMICOLON
    //  ;

    //using_namespace_directive
    //  : USING namespace_name SEMICOLON 
    //  ;

    //namespace_declaration
    //  : NAMESPACE qualified_identifier namespace_body semicolon,
    //  ;

    //qualified_identifier
    //  : IDENTIFIER
    //  | qualified_identifier DOT IDENTIFIER 
    //  ;

    //namespace_name
    //  : namespace_or_type_name
    //  ;

    //namespace_body
    //  : OPEN_BRACE using_directive~, namespace_member_declaration~, CLOSE_BRACE
    //  ;

    //namespace_member_declaration
    //  : type_declaration
    //  | namespace_declaration
    //  ;

    //type_declaration
    //  : class_declaration		
    //  | struct_declaration		
    //  | interface_declaration		
    //  | enum_declaration		
    //  | delegate_declaration
    //  ;

    //attribute_section
    //  : OPEN_BRACKET attribute_target_specifier attribute_list CLOSE_BRACKET
    //  | OPEN_BRACKET attribute_list CLOSE_BRACKET
    //  ;

    //attribute_target_specifier
    //  : attribute_target COLON
    //  ;

    //attribute_target
    //  : IDENTIFIER
    //  | EVENT
    //  | RETURN
    //  ;

    //attribute_list
    //  : attribute
    //  | attribute_list COMMA attribute
    //  ;

    //attribute
    //  : attribute_name attribute_arguments,
    //  ;

    //attribute_name
    //  : qualified_identifier
    //  ;

    //attribute_arguments
    //  : positional_argument_list
    //  | positional_argument_list COMMA named_argument_list
    //  | named_argument_list
    //  ;


    //positional_argument_list
    //  : expression
    //  | positional_argument_list COMMA expression
    //  ;

    //named_argument_list
    //  : named_argument
    //  | named_argument_list COMMA named_argument
    //  ;

    //named_argument
    //  : IDENTIFIER ASSIGN expression
    //  ;


    //class_body
    //  :  OPEN_BRACE class_member_declaration~, CLOSE_BRACE
    //  ;

    //class_member_declaration
    //  : constant_declaration
    //  | field_declaration
    //  | method_declaration
    //  | property_declaration
    //  | event_declaration
    //  | indexer_declaration
    //  | operator_declaration
    //  | constructor_declaration
    //  | destructor_declaration
    //  | type_declaration
    //  ;

    //struct_declaration
    //  : attribute_section~, modifier~, STRUCT IDENTIFIER struct_interface~, struct_body semicolon,
    //  ;

    //struct_interface
    //  : COLON type_list
    //  ;

    //struct_body
    //  : OPEN_BRACE struct_member_declaration~, CLOSE_BRACE
    //  ;

    //struct_member_declaration
    //  : constant_declaration
    //  | field_declaration
    //  | method_declaration
    //  | property_declaration
    //  | event_declaration
    //  | indexer_declaration
    //  | operator_declaration
    //  | constructor_declaration
    //  | type_declaration
    //  | destructor_declaration 
    //  ;

    //constant_declaration
    //  :  attribute_section~, modifier~ CONST type constant_declarators SEMICOLON
    //  ;

    //constant_declarators
    //  : constant_declarator 
    //  | constant_declarators COMMA constant_declarator
    //  ;

    //constant_declarator
    //  : IDENTIFIER ASSIGN constant_expression COMMA 
    //  ;

    //field_declaration
    //  :  attribute_section~, modifier~, type variable_declarators SEMICOLON
    //  ;

    //variable_declarators
    //  : variable_declarator 
    //  | variable_declarators COMMA variable_declarator
    //  ;

    //variable_declarator
    //  : IDENTIFIER ASSIGN variable_initializer
    //  | IDENTIFIER
    //  ;

    //variable_initializer
    //  : expression
    //  | array_initializer
    //  | STACKALLOC type OPEN_BRACKET expression CLOSE_BRACKET
    //  ;

    //method_declaration
    //  : method_header
    //    method_body
    //  ;

    //method_header
    //  :  attribute_section~, modifier~, type member_name OPEN_PARENS formal_parameter_list, CLOSE_PARENS 
    //  |  attribute_section~, modifier~, VOID member_name OPEN_PARENS formal_parameter_list, CLOSE_PARENS 
    //  ;

    //method_body
    //  : block
    //  | SEMICOLON
    //  ;

    //formal_parameter_list
    //  : fixed_parameters		
    //  | fixed_parameters COMMA parameter_array
    //  | parameter_array 
    //  ;

    //fixed_parameters
    //  : fixed_parameter	
    //  | fixed_parameters COMMA fixed_parameter
    //  ;

    //fixed_parameter
    //  :  attribute_section~,
    //    parameter_modifier,
    //    type
    //    IDENTIFIER
    //  ;

    //parameter_modifier
    //  : REF			
    //  | OUT		
    //  ;

    //parameter_array
    //  :  attribute_section~,PARAMS type IDENTIFIER
    //  ;

    //member_name 
    //  : qualified_identifier
    //  ;

    //property_declaration
    //  :  attribute_section~, modifier~, type member_name OPEN_BRACE accessor_declarations CLOSE_BRACE
    //  ;

    //accessor_declarations
    //  : get_accessor_declaration set_accessor_declaration,
    //  | set_accessor_declaration get_accessor_declaration,
    //  ;

    //get_accessor_declaration
    //  :  attribute_section~,GET accessor_body
    //  ;

    //set_accessor_declaration
    //  :  attribute_section~,SET accessor_body
    //  ;

    //accessor_body
    //  : block 
    //  | SEMICOLON		
    //  ;

    //interface_declaration
    //  :  attribute_section~, modifier~, INTERFACE IDENTIFIER interface_base, interface_body
    //  ;

    //interface_base
    //  : COLON interface_type_list
    //  ;

    //interface_type_list
    //  : interface_type
    //  | interface_type_list COMMA interface_type
    //  ;

    //interface_body
    //  : OPEN_BRACE interface_member_declaration~, CLOSE_BRACE
    //  ;

    //interface_member_declaration
    //  : interface_method_declaration		
    //  | interface_property_declaration	
    //  | interface_event_declaration 
    //  | interface_indexer_declaration
    //  ;

    //interface_method_declaration
    //  :  attribute_section~,new, type IDENTIFIER OPEN_PARENS formal_parameter_list, CLOSE_PARENS SEMICOLON
    //  |  attribute_section~,new, VOID IDENTIFIER OPEN_PARENS formal_parameter_list, CLOSE_PARENS SEMICOLON
    //  ;

    //interface_property_declaration
    //  :  attribute_section~, new, type IDENTIFIER OPEN_BRACE interface_accesors CLOSE_BRACE
    //  ;

    //interface_accesors
    //  :  attribute_section~,GET SEMICOLON
    //  |  attribute_section~,SET SEMICOLON
    //  |  attribute_section~,GET SEMICOLON attribute_section~,SET SEMICOLON 
    //  |  attribute_section~,SET SEMICOLON attribute_section~,GET SEMICOLON
    //  ;

    //interface_event_declaration
    //  :  attribute_section~,new, EVENT type IDENTIFIER SEMICOLON
    //  ;

    //interface_indexer_declaration 
    //  :  attribute_section~,new, type THIS OPEN_BRACKET formal_parameter_list, CLOSE_BRACKET
    //    OPEN_BRACE interface_accesors CLOSE_BRACE
    //  ;

    //operator_declaration
    //  :  attribute_section~,modifier~, operator_declarator block
    //  ;

    //operator_declarator
    //  : type OPERATOR overloadable_operator OPEN_PARENS type IDENTIFIER CLOSE_PARENS
    //  | type OPERATOR overloadable_operator OPEN_PARENS type IDENTIFIER COMMA type IDENTIFIER CLOSE_PARENS
    //  | conversion_operator_declarator
    //  ;

    //overloadable_operator
    //  : BANG 
    //  | TILDE
    //  | OP_INC
    //  | OP_DEC
    //  | TRUE  
    //  | FALSE 
    //  | PLUS 
    //  | MINUS
    //  | STAR 
    //  | DIV 
    //  | PERCENT 
    //  | BITWISE_AND 
    //  | BITWISE_OR 
    //  | CARRET 
    //  | OP_SHIFT_LEFT 
    //  | OP_SHIFT_RIGHT
    //  | OP_EQ 
    //  | OP_NE 
    //  | OP_GT 
    //  | OP_LT 
    //  | OP_GE 
    //  | OP_LE 
    //  ;


    //conversion_operator_declarator
    //  : IMPLICIT OPERATOR type OPEN_PARENS type IDENTIFIER CLOSE_PARENS
    //  | EXPLICIT OPERATOR type OPEN_PARENS type IDENTIFIER CLOSE_PARENS
    //  | IMPLICIT error 
    //  | EXPLICIT error 
    //  ;

    //constructor_declaration
    //  :  attribute_section~, modifier~, constructor_declarator block
    //  ;

    //constructor_declarator
    //  : IDENTIFIER OPEN_PARENS formal_parameter_list, CLOSE_PARENS constructor_initializer,
    //  ;

    //constructor_initializer
    //  : COLON BASE OPEN_PARENS argument_list, CLOSE_PARENS
    //  | COLON THIS OPEN_PARENS argument_list, CLOSE_PARENS
    //  ;

    //destructor_declaration
    //  :  attribute_section~,TILDE IDENTIFIER OPEN_PARENS CLOSE_PARENS block
    //  ;

    //event_declaration
    //  :  attribute_section~, modifier~, EVENT type variable_declarators SEMICOLON
    //  |  attribute_section~, modifier~, EVENT type member_name OPEN_BRACE event_accessor_declarations CLOSE_BRACE
    //  ;

    //event_accessor_declarations
    //  : add_accessor_declaration remove_accessor_declaration
    //  | remove_accessor_declaration add_accessor_declaration
    //  ;

    //add_accessor_declaration
    //  :  attribute_section~,ADD block
    //  ;

    //remove_accessor_declaration
    //  :  attribute_section~,REMOVE block
    //  ;

    //indexer_declaration
    //  :  attribute_section~,modifier~, indexer_declarator OPEN_BRACE CLOSE_BRACE
    //  ;

    //indexer_declarator
    //  : type THIS OPEN_BRACKET formal_parameter_list, CLOSE_BRACKET
    //  | type qualified_identifier DOT THIS OPEN_BRACKET formal_parameter_list, CLOSE_BRACKET
    //  ;

    //enum_declaration
    //  :  attribute_section~, modifier~, ENUM IDENTIFIER enum_base, enum_body
    //    semicolon,
    //  ;

    //enum_base
    //  : COLON type
    //  ;

    //enum_body
    //  : OPEN_BRACE opt_enum_member_declarations CLOSE_BRACE
    //  ;

    //opt_enum_member_declarations
    //  : 
    //  | enum_member_declarations comma,
    //  ;

    //enum_member_declarations
    //  : enum_member_declaration 
    //  | enum_member_declarations COMMA enum_member_declaration
    //  ;

    //enum_member_declaration
    //  :  attribute_section~,IDENTIFIER 
    //  |  attribute_section~,IDENTIFIER ASSIGN expression
    //  ;

    //delegate_declaration
    //  :  attribute_section~, modifier~, DELEGATE type	IDENTIFIER 
    //  OPEN_PARENS formal_parameter_list, CLOSE_PARENS SEMICOLON
    //  |  attribute_section~, modifier~, DELEGATE VOID IDENTIFIER 
    //  OPEN_PARENS formal_parameter_list, CLOSE_PARENS SEMICOLON
    //  ;

    //type
    //  : qualified_identifier
    //  | builtin_types
    //  | array_type
    //  | pointer_type	  
    //  ;

    //pointer_type
    //  : type STAR
    //  | VOID STAR
    //  ;

    //non_expression_type
    //  : builtin_types	
    //  | non_expression_type rank_specifier
    //  | non_expression_type STAR
    //  | expression rank_specifier~
    //  | expression STAR 
    //  ;

    //type_list
    //  : type
    //  | type_list COMMA type
    //  ;

    //builtin_types
    //  : OBJECT
    //  | STRING
    //  | BOOL
    //  | DECIMAL
    //  | FLOAT
    //  | DOUBLE
    //  | integral_type
    //  ;

    //integral_type
    //  : SBYTE
    //  | BYTE
    //  | SHORT
    //  | USHORT
    //  | INT
    //  | UINT
    //  | LONG
    //  | ULONG
    //  | CHAR
    //  ;

    //interface_type
    //  : qualified_identifier
    //  ;

    //array_type
    //  : type rank_specifier~
    //  ;

    //primary_expression
    //  : literal
    //  | qualified_identifier
    //  | parenthesized_expression
    //  | member_access
    //  | invocation_expression
    //  | element_access
    //  | this_access
    //  | base_access
    //  | post_increment_expression
    //  | post_decrement_expression
    //  | new_expression
    //  | typeof_expression
    //  | sizeof_expression
    //  | checked_expression
    //  | unchecked_expression
    //  | pointer_member_access
    //  | pointer_element_access
    //  | sizeof-expression
    //  ;

    //literal
    //  : boolean_literal
    //  | integer_literal
    //  | real_literal
    //  | LITERAL_CHARACTER
    //  | LITERAL_STRING
    //  | NULL
    //  ;

    //real_literal
    //  : LITERAL_FLOAT
    //  | LITERAL_DOUBLE
    //  | LITERAL_DECIMAL
    //  ;

    //integer_literal
    //  : LITERAL_INTEGER
    //  ;

    //boolean_literal
    //  : TRUE
    //  | FALSE
    //  ;

    //parenthesized_expression
    //  : OPEN_PARENS expression CLOSE_PARENS
    //  ;

    //member_access
    //  : primary_expression DOT IDENTIFIER
    //  | predefined_type DOT IDENTIFIER
    //  ;

    //predefined_type
    //  : builtin_types
    //  ;

    //invocation_expression
    //  : primary_expression OPEN_PARENS argument_list, CLOSE_PARENS
    //  ; 

    //argument_list
    //  : argument		
    //  | argument_list COMMA argument
    //  ;

    //argument
    //  : expression
    //  | REF variable_reference 
    //  | OUT variable_reference 
    //  ;

    //variable_reference
    //  : expression
    //  ;

    //element_access
    //  : primary_expression OPEN_BRACKET expression_list CLOSE_BRACKET	
    //  | primary_expression rank_specifier~
    //  ;

    //expression_list
    //  : expression
    //  | expression_list COMMA expression
    //  ;

    //this_access
    //  : THIS
    //  ;

    //base_access
    //  : BASE DOT IDENTIFIER
    //  | BASE OPEN_BRACKET expression_list CLOSE_BRACKET
    //  ;

    //post_increment_expression
    //  : primary_expression OP_INC
    //  ;

    //post_decrement_expression
    //  : primary_expression OP_DEC
    //  ;

    //new_expression
    //  : object_or_delegate_creation_expression
    //  | array_creation_expression
    //  ;

    //object_or_delegate_creation_expression
    //  : NEW type OPEN_PARENS argument_list, CLOSE_PARENS
    //  ;

    //array_creation_expression
    //  : NEW type OPEN_BRACKET expression_list CLOSE_BRACKET 
    //    rank_specifier~,
    //    array_initializer,
    //  | NEW type rank_specifier~ array_initializer
    //  | NEW type error 
    //  ;

    //rank_specifier
    //  : OPEN_BRACKET dim_separator~, CLOSE_BRACKET
    //  ;

    //array_initializer
    //  : OPEN_BRACE CLOSE_BRACE
    //  | OPEN_BRACE variable_initializer_list comma, CLOSE_BRACE
    //  ;

    //variable_initializer_list
    //  : variable_initializer
    //  | variable_initializer_list COMMA variable_initializer
    //  ;

    //typeof_expression
    //  : TYPEOF OPEN_PARENS type CLOSE_PARENS
    //  ;

    //sizeof_expression
    //  : SIZEOF OPEN_PARENS type CLOSE_PARENS
    //  ;

    //checked_expression
    //  : CHECKED OPEN_PARENS expression CLOSE_PARENS
    //  ;

    //unchecked_expression
    //  : UNCHECKED OPEN_PARENS expression CLOSE_PARENS
    //  ;

    //pointer_member_access 
    //  : primary_expression OP_PTR IDENTIFIER
    //  ;

    //unary_expression
    //  : primary_expression
    //  | BANG prefixed_unary_expression
    //  | TILDE prefixed_unary_expression
    //      | OPEN_PARENS expression CLOSE_PARENS unary_expression
    //      | OPEN_PARENS non_expression_type CLOSE_PARENS prefixed_unary_expression
    //  ;

    //prefixed_unary_expression
    //  : unary_expression
    //  | PLUS prefixed_unary_expression
    //  | MINUS prefixed_unary_expression 
    //  | OP_INC prefixed_unary_expression 
    //  | OP_DEC prefixed_unary_expression 
    //  | STAR prefixed_unary_expression
    //  | BITWISE_AND prefixed_unary_expression
    //  ;

    //pre_increment_expression
    //  : OP_INC prefixed_unary_expression 
    //  ;

    //pre_decrement_expression
    //  : OP_DEC prefixed_unary_expression 
    //  ;

    //multiplicative_expression
    //  : prefixed_unary_expression
    //  | multiplicative_expression STAR prefixed_unary_expression
    //  | multiplicative_expression DIV prefixed_unary_expression
    //  | multiplicative_expression PERCENT prefixed_unary_expression 
    //  ;

    //additive_expression
    //  : multiplicative_expression
    //  | additive_expression PLUS multiplicative_expression 
    //  | additive_expression MINUS multiplicative_expression
    //  ;

    //shift_expression
    //  : additive_expression
    //  | shift_expression OP_SHIFT_LEFT additive_expression
    //  | shift_expression OP_SHIFT_RIGHT additive_expression
    //  ; 

    //relational_expression
    //  : shift_expression
    //  | relational_expression OP_LT shift_expression
    //  | relational_expression OP_GT shift_expression
    //  | relational_expression OP_LE shift_expression
    //  | relational_expression OP_GE shift_expression
    //  | relational_expression IS type
    //  | relational_expression AS type
    //  ;

    //equality_expression
    //  : relational_expression
    //  | equality_expression OP_EQ relational_expression
    //  | equality_expression OP_NE relational_expression
    //  ; 

    //and_expression
    //  : equality_expression
    //  | and_expression BITWISE_AND equality_expression
    //  ;

    //exclusive_or_expression
    //  : and_expression
    //  | exclusive_or_expression CARRET and_expression
    //  ;

    //inclusive_or_expression
    //  : exclusive_or_expression
    //  | inclusive_or_expression BITWISE_OR exclusive_or_expression
    //  ;

    //conditional_and_expression
    //  : inclusive_or_expression
    //  | conditional_and_expression OP_AND inclusive_or_expression
    //  ;

    //conditional_or_expression
    //  : conditional_and_expression
    //  | conditional_or_expression OP_OR conditional_and_expression
    //  ;

    //conditional_expression
    //  : conditional_or_expression
    //  | conditional_or_expression INTERR expression COLON expression 
    //  ;

    //assignment_expression
    //  : prefixed_unary_expression ASSIGN expression
    //  | prefixed_unary_expression OP_MULT_ASSIGN expression
    //  | prefixed_unary_expression OP_DIV_ASSIGN expression
    //  | prefixed_unary_expression OP_MOD_ASSIGN expression
    //  | prefixed_unary_expression OP_ADD_ASSIGN expression
    //  | prefixed_unary_expression OP_SUB_ASSIGN expression
    //  | prefixed_unary_expression OP_SHIFT_LEFT_ASSIGN expression
    //  | prefixed_unary_expression OP_SHIFT_RIGHT_ASSIGN expression
    //  | prefixed_unary_expression OP_AND_ASSIGN expression
    //  | prefixed_unary_expression OP_OR_ASSIGN expression
    //  | prefixed_unary_expression OP_XOR_ASSIGN expression
    //  ;

    //expression
    //  : conditional_expression
    //  | assignment_expression
    //  ;

    //constant_expression
    //  : expression
    //  ;

    //boolean_expression
    //  : expression
    //  ;

    //class_declaration
    //  :  attribute_section~, modifier~, CLASS IDENTIFIER class_base, class_body semicolon, 
    //  ;	

    //modifier
    //  : NEW
    //  | PUBLIC
    //  | PROTECTED
    //  | INTERNAL
    //  | PRIVATE
    //  | ABSTRACT
    //  | SEALED
    //  | STATIC
    //  | READONLY
    //  | VIRTUAL
    //  | OVERRIDE
    //  | EXTERN
    //  | VOLATILE
    //  | UNSAFE
    //  ;

    //class_base
    //  : COLON type_list
    //  ;

    //block
    //  : OPEN_BRACE statement~, CLOSE_BRACE 
    //  ;

    //statement
    //  : declaration_statement
    //  | embedded_statement
    //  | labeled_statement
    //  ;

    //embedded_statement
    //  : block
    //  | empty_statement
    //      | expression_statement
    //  | selection_statement
    //  | iteration_statement
    //  | jump_statement		  
    //  | try_statement
    //  | checked_statement
    //  | unchecked_statement
    //  | lock_statement
    //  | using_statement
    //  | unsafe_statement
    //  | fixed_statement
    //  ;

    //empty_statement
    //  : SEMICOLON
    //  ;

    //labeled_statement
    //  : IDENTIFIER COLON 
    //    statement
    //  ;

    //declaration_statement
    //  : local_variable_declaration SEMICOLON
    //  | local_constant_declaration SEMICOLON
    //  ;


    //local_variable_type
    //  : primary_expression rank_specifier,
    //  | builtin_types rank_specifier,
    //        ;

    //local_variable_pointer_type
    //  : primary_expression STAR
    //    | builtin_types STAR
    //        | VOID STAR
    //  | local_variable_pointer_type STAR
    //    ;

    //local_variable_declaration
    //  : local_variable_type variable_declarators
    //        | local_variable_pointer_type rank_specifier, variable_declarators
    //  ;

    //local_constant_declaration
    //  : CONST local_variable_type constant_declarator
    //  ;

    //expression_statement
    //  : statement_expression SEMICOLON
    //  ;

    //statement_expression
    //  : invocation_expression		
    //  | object_creation_expression
    //  | assignment_expression
    //  | post_increment_expression
    //  | post_decrement_expression
    //  | pre_increment_expression
    //  | pre_decrement_expression
    //  | error
    //  ;

    //object_creation_expression
    //  : object_or_delegate_creation_expression
    //  ;

    //selection_statement
    //  : if_statement
    //  | switch_statement
    //  ; 

    //if_statement
    //  : IF OPEN_PARENS boolean_expression CLOSE_PARENS embedded_statement
    //  | IF OPEN_PARENS boolean_expression CLOSE_PARENS embedded_statement ELSE embedded_statement
    //  ;

    //switch_statement
    //  : SWITCH OPEN_PARENS expression CLOSE_PARENS switch_block
    //  ;

    //switch_block
    //  : OPEN_BRACE switch_section~, CLOSE_BRACE
    //  ;

    //switch_section
    //  : switch_label~ statement_list 
    //  ;

    //switch_label
    //  : CASE constant_expression COLON
    //  | DEFAULT COLON				
    //  | error 
    //  ;

    //iteration_statement
    //  : while_statement
    //  | do_statement
    //  | for_statement
    //  | foreach_statement
    //  ;

    //while_statement
    //  : WHILE OPEN_PARENS boolean_expression CLOSE_PARENS embedded_statement
    //  ;

    //do_statement
    //  : DO embedded_statement 
    //    WHILE OPEN_PARENS boolean_expression CLOSE_PARENS SEMICOLON
    //  ;

    //for_statement
    //  : FOR OPEN_PARENS for_initializer, SEMICOLON for_condition, SEMICOLON for_iterator, CLOSE_PARENS embedded_statement
    //  ;

    //for_initializer
    //  : local_variable_declaration
    //  | statement_expression_list
    //  ;

    //for_iterator
    //  : statement_expression_list
    //  ;

    //statement_expression_list
    //  : statement_expression	
    //  | statement_expression_list COMMA statement_expression
    //  ;

    //foreach_statement
    //  : FOREACH OPEN_PARENS type IDENTIFIER IN expression CLOSE_PARENS embedded_statement 
    //  ;

    //jump_statement
    //  : break_statement
    //  | continue_statement
    //  | goto_statement
    //  | return_statement
    //  | throw_statement
    //  ;

    //break_statement
    //  : BREAK SEMICOLON
    //  ;

    //continue_statement
    //  : CONTINUE SEMICOLON
    //  ;

    //goto_statement
    //  : GOTO IDENTIFIER SEMICOLON 
    //  | GOTO CASE constant_expression SEMICOLON
    //  | GOTO DEFAULT SEMICOLON 
    //  ; 

    //return_statement
    //  : RETURN expression, SEMICOLON
    //  ;

    //throw_statement
    //  : THROW expression, SEMICOLON
    //  ;

    //try_statement
    //  : TRY block catch_clause~ 
    //  | TRY block catch_clause~, FINALLY block
    //  | TRY block error 
    //  ;

    //catch_clause 
    //  : CATCH catch_args, block 
    //        ;

    //catch_args 
    //        : OPEN_PARENS type identifier, CLOSE_PARENS 
    //      ;

    //checked_statement
    //  : CHECKED block
    //  ;

    //unchecked_statement
    //  : UNCHECKED block
    //  ;

    //unsafe_statement
    //  : UNSAFE 
    //    block 
    //  ;

    //fixed_statement
    //  : FIXED OPEN_PARENS pointer_type fixed_pointer_declarators CLOSE_PARENS embedded_statement 
    //  ;

    //fixed_pointer_declarators
    //  : fixed_pointer_declarator
    //  | fixed_pointer_declarators COMMA fixed_pointer_declarator
    //  ;

    //fixed_pointer_declarator
    //  : IDENTIFIER ASSIGN expression
    //  ;

    //lock_statement
    //  : LOCK OPEN_PARENS expression CLOSE_PARENS embedded_statement
    //  ;

    //using_statement
    //  : USING OPEN_PARENS resource_acquisition CLOSE_PARENS embedded_statement
    //  ; 

    //resource_acquisition
    //  : local_variable_declaration
    //  | expression
    //  ;
    #endregion
    #region Token Definitions
    //EOF
    //  : EOF
    //  ;
    //NONE
    //  : NONE
    //  ;
    //ERROR
    //  : ERROR
    //  ;
    //ABSTRACT
    //  : "abstract"
    //  ;
    //AS
    //  : "as"
    //  ;
    //ADD
    //  : "add"
    //  ;
    //ASSEMBLY
    //  : "assembly"
    //  ;
    //BASE
    //  : "base"
    //  ;
    //BOOL
    //  : "bool"
    //  ;
    //BREAK
    //  : "break"
    //  ;
    //BYTE
    //  : "byte"
    //  ;
    //CASE
    //  : "case"
    //  ;
    //CATCH
    //  : "catch"
    //  ;
    //CHAR
    //  : "char"
    //  ;
    //CHECKED
    //  : "checked"
    //  ;
    //CLASS
    //  : "class"
    //  ;
    //CONST
    //  : "const"
    //  ;
    //CONTINUE
    //  : "continue"
    //  ;
    //DECIMAL
    //  : "decimal"
    //  ;
    //DEFAULT
    //  : "default"
    //  ;
    //DELEGATE
    //  : "delegate"
    //  ;
    //DO
    //  : "do"
    //  ;
    //DOUBLE
    //  : "double"
    //  ;
    //ELSE
    //  : "else"
    //  ;
    //ENUM
    //  : "enum"
    //  ;
    //EVENT
    //  : "event"
    //  ;
    //EXPLICIT
    //  : "explicit"
    //  ;
    //EXTERN
    //  : "extern"
    //  ;
    //FALSE
    //  : "false"
    //  ;
    //FINALLY
    //  : "finally"
    //  ;
    //FIXED
    //  : "fixed"
    //  ;
    //FLOAT
    //  : "float"
    //  ;
    //FOR	
    //  : "for"
    //  ;
    //FOREACH
    //  : "foreach"
    //  ;
    //GOTO
    //  : "goto"
    //  ;
    //IF	
    //  : "if"
    //  ;
    //IMPLICIT
    //  : "implicit"
    //  ;
    //IN	
    //  : "in"
    //  ;
    //INT	
    //  : "int"
    //  ;
    //INTERFACE
    //  : "interface"
    //  ;
    //INTERNAL
    //  : "internal"
    //  ;
    //IS	
    //  : "is"
    //  ;
    //LOCK
    //  : "lock"
    //  ;
    //LONG
    //  : "long"
    //  ;
    //NAMESPACE
    //  : "namespace"
    //  ;
    //NEW	
    //  : "new"
    //  ;
    //NULL
    //  : "null"
    //  ;
    //OBJECT
    //  : "object"
    //  ;
    //OPERATOR
    //  : "operator"
    //  ;
    //OUT	
    //  : "out"
    //  ;
    //OVERRIDE
    //  : "override"
    //  ;
    //PARAMS
    //  : "params"
    //  ;
    //PRIVATE
    //  : "private"
    //  ;
    //PROTECTED
    //  : "protected"
    //  ;
    //PUBLIC
    //  : "public"
    //  ;
    //READONLY
    //  : "readonly"
    //  ;
    //REF	
    //  : "ref"
    //  ;
    //RETURN
    //  : "return"
    //  ;
    //REMOVE
    //  : "remove"
    //  ;
    //SBYTE
    //  : "sbyte"
    //  ;
    //SEALED
    //  : "sealed"
    //  ;
    //SHORT
    //  : "short"
    //  ;
    //SIZEOF
    //  : "sizeof"
    //  ;
    //STACKALLOC
    //  : "stackalloc"
    //  ;
    //STATIC
    //  : "static"
    //  ;
    //STRING
    //  : "string"
    //  ;
    //STRUCT
    //  : "struct"
    //  ;
    //SWITCH
    //  : "switch"
    //  ;
    //THIS
    //  : "this"
    //  ;
    //THROW
    //  : "throw"
    //  ;
    //TRUE
    //  : "true"
    //  ;
    //TRY	
    //  : "try"
    //  ;
    //TYPEOF
    //  : "typeof"
    //  ;
    //UINT
    //  : "uint"
    //  ;
    //ULONG
    //  : "ulong"
    //  ;
    //UNCHECKED
    //  : "unchecked"
    //  ;
    //UNSAFE
    //  : "unsafe"
    //  ;
    //USHORT
    //  : "ushort"
    //  ;
    //USING
    //  : "using"
    //  ;
    //VIRTUAL
    //  : "virtual"
    //  ;
    //VOID
    //  : "void"
    //  ;
    //VOLATILE
    //  : "volatile"
    //  ;
    //WHILE
    //  : "while"
    //  ;
    //GET 
    //  : "get"
    //  ;
    //SET 
    //  : "set"
    //  ;
    //OPEN_BRACE
    //  : "{"
    //  ;
    //CLOSE_BRACE
    //  : "}"
    //  ;
    //OPEN_BRACKET
    //  : "["
    //  ;
    //CLOSE_BRACKET
    //  : "]"
    //  ;
    //OPEN_PARENS
    //  : "("
    //  ;
    //CLOSE_PARENS
    //  : ")"
    //  ;
    //DOT
    //  :"."
    //  ;
    //COMMA
    //  : ","
    //  ;
    //COLON
    //  : ":"
    //  ;
    //SEMICOLON
    //  : ";"
    //  ;
    //TILDE
    //  : "~"
    //  ;
    //PLUS
    //  : "+"
    //  ;
    //MINUS
    //  : "-"
    //  ;
    //BANG
    //  : "!"
    //  ;
    //ASSIGN
    //  : "="
    //  ;
    //OP_LT
    //  : "<"
    //  ;
    //OP_GT
    //  : ">"
    //  ;
    //BITWISE_AND
    //  : "&"
    //  ;
    //BITWISE_OR
    //  : "|"
    //  ;
    //STAR
    //  : "*"
    //  ;
    //PERCENT
    //  : "%"
    //  ;
    //DIV 
    //  : "/"
    //  ;
    //CARRET
    //  : "^"
    //  ;
    //INTERR
    //  : "?"
    //  ;
    //OP_INC
    //  : "++"
    //  ;
    //OP_DEC
    //  : "--"
    //  ;
    //OP_SHIFT_LEFT
    //  : "<<"
    //  ;
    //OP_SHIFT_RIGHT
    //  : ">>"
    //  ;
    //OP_LE
    //  : "<="
    //  ;
    //OP_GE
    //  : ">="
    //  ;
    //OP_EQ
    //  : "=="
    //  ;
    //OP_NE
    //  : "!="
    //  ;
    //OP_AND
    //  : "&&"
    //  ;
    //OP_OR
    //  : "||"
    //  ;
    //OP_MULT_ASSIGN
    //  : "*="
    //  ;
    //OP_DIV_ASSIGN
    //  : "/="
    //  ;
    //OP_MOD_ASSIGN
    //  : "%="
    //  ;
    //OP_ADD_ASSIGN
    //  : "+="
    //  ;
    //OP_SUB_ASSIGN
    //  : "-="
    //  ;
    //OP_SHIFT_LEFT_ASSIGN
    //  : "<<="
    //  ;
    //OP_SHIFT_RIGHT_ASSIGN
    //  : ">>="
    //  ;
    //OP_AND_ASSIGN
    //  : "&="
    //  ;
    //OP_XOR_ASSIGN
    //  : "^="
    //  ;
    //OP_OR_ASSIGN
    //  : "|="
    //  ;
    //OP_PTR
    //  : "->"
    //  ;

    //LITERAL_INTEGER
    //  : "int literal"
    //  ;
    //LITERAL_FLOAT
    //  : "float literal"
    //  ;
    //LITERAL_DOUBLE
    //  : "double literal"
    //  ;
    //LITERAL_DECIMAL
    //  : "decimal literal"
    //  ;
    //LITERAL_CHARACTER
    //  : "character literal"
    //  ;
    //LITERAL_STRING
    //  : "string literal"
    //  ;


    //IDENTIFIER
    //  : IDENTIFIER
    //  ;
    #endregion
  }





  #region Tests
  public class ConceptTestDefinition:ConceptDefinition
  {
    public class SignaturePoint : ConceptPoint
    {
      #region Shortcuts
      public static SignaturePoint of(string name)
      {
        return new SignaturePoint(name);
      }
      #endregion
      #region Statics
      public static readonly SignaturePoint Assembly = of("\0assembly\0");
      public static readonly SignaturePoint Module = of("\0module\0");
      public static readonly SignaturePoint Namespace = of("\0namespace\0");
      public static readonly SignaturePoint Class = of("\0class\0");
      public static readonly SignaturePoint Field = of("\0field\0");
      public static readonly SignaturePoint Event = of("\0event\0");
      public static readonly SignaturePoint Method = of("\0method\0");
      public static readonly SignaturePoint Property = of("\0property\0");
      public static readonly SignaturePoint Get = of("\0get\0");
      public static readonly SignaturePoint Set = of("\0set\0");
      public static readonly SignaturePoint Extends = of("\0extends\0");
      public static readonly SignaturePoint Implements = of("\0implements\0");
      public static readonly SignaturePoint Public = of("\0public\0");
      public static readonly SignaturePoint Protected = of("\0protected\0");
      public static readonly SignaturePoint Private = of("\0private\0");
      public static readonly SignaturePoint Internal = of("\0internal\0");
      public static readonly SignaturePoint ProtectedInternal = of("\0protected internal\0");
      public static readonly SignaturePoint DefineAs = of("\0define as\0");
      #endregion
      #region Fields
      #endregion
      #region Constructors
      public SignaturePoint(string name):base(name)
      {

      }
      #endregion
    }

    public override ConceptPoint Define()
    {
      return ConceptPoint.of(
        ///根据已知优先原则，public应为已知，所以可以放在car前面。
        ///class也是一个属性。object也是一个属性。
        ///通过“属性提取”可以将已知属性提取到属性属性列表之外，
        ///放入链接列表之中，所以"class"和"public"都将自动的转化
        ///为对应的标签（而不是属性）。需要注意的是，
        ///属性提取应尽可能处理唯一属性。虽然不建议使用关键字，
        ///但只有属性并不和任何语句中的语法成分相冲突，才可以
        ///立即提取。
        ///在内联代码中，可以使用一个简单的方式：\0包围。
              _["public"]["class"]["car"][_["extends"]["object"]][_["implements"][_["IDisposible"], _["ISerializable"]]][
                _["protected"]["Window"]["window"]
                [
                  _[SignaturePoint.Field]["handle"][
                    _[SignaturePoint.Method]["band", "verb"]["handle", "object"][
                      _["act"]
                    ]
                  ]
                ],
                _[SignaturePoint.Property]["public", "Window"][
                  _[SignaturePoint.Get],
                  _[SignaturePoint.Set]
                ],
                _[SignaturePoint.Method]["public"][_["open", "verb"]["window", "object"]]
                [
                ///  语句可以使用括号进行限定或者使用自动解析。
                  _["band"]["this"]["window"]["handle"]["to"]["left"]
                ]
              ]
            );

    }
    public virtual ConceptPoint DefineInternal()
    {
      return ConceptPoint.of(
        ///以下形式是上述形式的标定和转化后的结果，可以用来直接生成代码。
        /// 
              _[SignaturePoint.Public][SignaturePoint.Class]["car"][_[SignaturePoint.Extends]["object"]][_[SignaturePoint.Implements][_["IDisposible"], _["ISerializable"]]][
                _[SignaturePoint.Public][SignaturePoint.Field]["window"][SignaturePoint.DefineAs]["Window"]
                [
                  _[SignaturePoint.Field]["handle"][
                    _[SignaturePoint.Method]["band", "verb"]["handle", "object"][
                      _["act"]
                    ]
                  ]
                ],
                _[SignaturePoint.Public][SignaturePoint.Property]["Window"][SignaturePoint.DefineAs]["Window"][
                  _[SignaturePoint.Get],
                  _[SignaturePoint.Set]
                ],
                _[SignaturePoint.Method]["public"][_["open", "verb"]["window", "object"]]
                [
        ///  语句可以使用括号进行限定或者自动解析。
                  _["band"]["this"]["window"]["handle"]["to"]["left"]
                ]
              ]
            );

    }
  }

  //compilation_unit
  //  : using_directive~, namespace_member_declaration~, attribute_section~,EOF,
  //  ; 
  public class Compilation_Unit : ConceptPoint
  {
    /// <summary>
    /// 定义可以放置于特定的方法上或者放置于构造函数上。
    /// 
    /// 如何使用括号定义：
    /// 
    /// ["compilation_unit"]
    /// [
    ///   ["using_directive","optional","repeatable"]["namespace_member_declarations","optional","repeatable"]["attribute_sections","optional","repeatable"]["eof","optional"]
    ///   [
    ///     在这里可以做解释性并置，也就是构造方法的实现。
    ///     实现可以只是属性的并置或者是更为具体的子节点列表。
    ///   ]
    /// ]
    /// [
    ///   [另一个构造……]
    ///   //用一个序列定义一个未知的语素，就是语素对应的类的构造方法，也是语素的BNF定义式。
    ///   //当我们说出以上序列的时候，已经隐式的构造了这个对象。
    ///   //无需显式定义构造方法，这就是构造方法。
    ///   //构造方法的参数就是这个类的实例化调用。
    /// ]
    /// [
    ///   [其他字段，属性或者方法]
    ///   //要保证这个部分为[[],[]]。
    /// ]
    /// 使用直接连接的二元关系就可以定义构造函数，因为一个直接关联的括号中有且只有
    /// 一个定义，这个定义只能是二元等价关系的细化。
    /// 
    /// 由于语义由系统自动生成，所以永远不用使用显式的“of”快捷方式。
    /// 构造方法直接生成new语义并提供一定的转换能力，转换能力依据BNF的定义不同而存在差别。
    /// 
    /// 
    /// 模式判别条件：
    /// 
    ///   引入语素为未知（或者最终归结为未知）；一系列已知语素（或者在它处定义的语素）的并置序列的封装
    ///   和引入语素并置。
    /// 
    /// 问题，如何更好的区分构造和非构造方法？
    /// 怎样才能正确的区分方法并置和类型并置？
    /// 
    /// 方法并置：  
    ///     ["open"][ ["window"]["Window"] ]["slightly"]
    ///     [
    /// 
    ///     ]
    /// 类型并置：
    ///     ["open"]["verb"]
    /// 
    /// 方法并置比类型并置具有更深的层次。方法并置具有内涵的类型并置（或者同位并置）。
    /// 
    /// 这使得方法并置更像构造模式。
    /// 
    /// 究竟如何区分方法并置和类型并置？
    /// 
    /// 方法并置的直接子层应具有动作性语义，而类型并置的直接子层不能具有动作性语义。
    /// 
    /// 方法并置的直接子层可以具有非动作性语义，可以含有内部类（最终被处理在外部）。
    /// 
    /// 不能依赖和未知语素并置的类型来唯一决定被并置类型是方法还是类。
    /// 
    /// 
    /// 例如open的并置形式，完全可以是定义open或者是执行open，几乎无法区别。
    /// 
    /// 事物描述性，过程描述性？
    /// 
    /// 是否使用这个方法：
    /// 
    ///     如果并置右侧的子层定义中显式出现“构造方法”就是方法。
    ///         ～～～～
    /// 
    /// 还是不行！无法区分Field，Property，等其他成员。
    /// 
    /// 解决了：
    /// 
    /// 方法全都是应用性的并置！真正的方法，在子层上只有一个连续并置。
    /// 
    /// 由于方法本身表达的是在时间上连续的过程，所以方法只有一个应用性的
    /// 连续并置。
    /// 
    /// 可能出现一个例外，就是在方法中存在变量的定义，它可以不是并置的，
    /// 但变量必须先定义然后使用的原则使得它必须是并置的。－如果它可以
    /// 不必并置，那么连续并置条件将不成立－然而，即便如此，还有另一个
    /// 条件－非定义性条件：
    ///   方法内部必须是非定义的。
    /// 由于方法中的所有组分都只能是陈述（statement），而一个陈述不应当
    /// 跨越它的边界，所以任何定义都只能在陈述中进行，可是这样的定义
    /// 并无实际意义。
    /// 
    /// 如果破坏这个条件呢？
    /// 
    /// 变量定义是什么意思？
    /// 
    /// 变量定义实质上是动作性的，也就是把变量名称和类型关联起来，所以变量定义
    /// 也是动作性的陈述（内部操作）。而变量定义将在包含它的[]中存在。
    /// 
    /// 关于局部陈述：
    /// 
    ///     局部陈述定义了一个区域，它仍然是陈述，它一般没有名字（有时有标号）。
    /// 
    /// 如何区别局部陈述和内部类？
    /// 
    ///     局部陈述也只有一个连续并置子层。也就是[[][][]...]
    ///     而内部类则是[[],[],[]]
    /// 
    /// 如何解释特殊情况[[]]，无法区分并置和子层列表，或者说，一个定义只有一个成员以及一个方法只有一个陈述？
    /// 
    /// 
    /// 这样区分：引入省略。
    /// 
    /// 对于定义，必须有省略。意味着定义可以扩展。而对于方法，由于并置本身可以扩展所以绝对不能使用省略（否则方法变成了定义）。
    /// 
    /// 由此，使用省略来区分定义和方法！
    /// 
    /// 概念：对事物的认知不必闭合，而对过程的进行必须有结束。
    /// 使用省略表达对事物的认知，而不使用省略表达过程的终结（一个过程不可能永不终结）。
    /// 
    /// 省略是一个特殊的符号，指明当前论域为一个事物描述。
    /// 
    ///    ["..."]
    /// 
    /// 关于字段：
    /// 
    /// 
    /// 如何定义字段以及字段的Initializer？
    /// 
    /// ["int"]["myfield"]
    /// 
    /// ["int"]["myfield"]
    /// [
    ///   [statement][statement][...],
    ///   [...]
    /// ]
    /// 
    /// 使用省略结束子层。这表示字段是一个事物描述而不是过程描述，过程描述只是一个部分。
    /// 
    /// 如何定义属性Property：
    /// 
    /// ["int"]["myproperty"]
    /// 
    /// ["int"]["myproperty"]
    /// [
    ///   ["get"][[statement][statement]...],
    ///   ["set"][[statement][statement]...],
    ///   ["other"][[statement][statement]...],
    ///   [...]
    /// ]    
    /// 
    /// 若字段含有特定名称的方法，则定义为属性Property。
    /// 
    /// 如何区分字段（属性）和类（定义）？
    /// 
    /// 使用类型前缀定义字段（属性），使用类型后缀定义类。
    /// 
    /// ["car"]["object"]
    /// [
    ///   ["..."]
    /// ]
    /// 
    /// 或者
    /// 
    /// ["car"]["object"]["..."]
    /// 
    /// 由于存在属性提取，上面的定义还可以写作
    /// 
    /// ["car","..."]["object"]
    /// 
    /// 
    /// 
    /// 
    /// 如何定义方法：
    /// 
    /// [][[][][]][[statement][statement][statement]]
    /// 
    /// 前面为签名和属性，后面至多只有一个语素（可以没有语素），其子层中也只有一个语素，为语句的并置。
    /// 
    /// 方法签名也包含于一个子层，而且签名是一个并置。
    /// 
    /// 返回类型和其他两部分并置，可能有子层，可能没有返回类型（缺省为当前类型/Void类型）。
    /// 
    /// 
    /// 假定左侧被右侧定义。特定语言系统可以通过更改BNF更改这一顺序。
    /// 
    /// 整个方法定义不允许含有省略[...]。
    /// 
    /// 
    /// 区别方法和定义：
    /// 
    /// 并置中含有省略或者并置的任何一个语素的子层中含有省略则为定义；
    /// 
    /// 否则为方法。
    /// 
    /// 约定在方法之中的任何层次的子层不可以含有省略。
    /// 
    /// 关于构造方法：
    /// 
    /// 构造方法符合
    /// [[][]][ [] [] [] ]
    /// 这种形式，而且如果不计其他成员，则为一个纯粹的方法形式。
    /// 
    /// 所以，它是一个“部分方法”和一个“部分定义”的结合。
    /// 
    /// 普通方法只有返回类型，签名和方法体三个并置，而构造方法则
    /// 由定义头和若干定义体的并置构成并置。
    /// 
    /// 定义头包含未知部分，所以显然不同于返回类型。定义体之间是并置关系，
    /// 所以不符合方法只有一个定义体的要求。
    /// 
    /// 构造方法模式为： 定义头和一系列语素并置，每个并置语素的子层只有一个语素，它是一个方法，
    /// 这个方法可能没有方法体。
    /// 
    /// 
    /// 使用构造语法即可调用构造函数，构造出对应的对象来。
    /// 
    /// 构造语法的调用是自动的，也是根据上下文在编译时确定的。
    /// 
    /// 
    /// 是否可以定义那些没有返回类型（Void也是一种返回类型）的方法为构造方法？
    /// 
    /// 似乎可以！这将简化设计！
    /// 
    /// 由于方法并没有方法名，所以类型必须和一个内嵌的方法签名并置：
    /// 
    /// [type][方法签名=[][][] ...][方法体]
    /// 
    /// 类型可以前并置或者后并置，没有区别。
    /// 
    /// 若没有类型则标识方法为构造方法，返回类型缺省为自身的类型。
    /// 
    /// 
    /// 省略可以被理解为“排列符号”。在子层使用“，”分开的语素之间的关系称为排列。
    /// 
    /// 排列不计语素之间的顺序（尽管实现者应保持这一顺序）。“...”意味着语素含有
    /// 排列子层。而排列子层的子层有权含有更进一步的排列子层。非排列子层只能含有非
    /// 排列子层。
    /// 
    /// 所谓非排列子层，是指子层之中只能有一个语素，当然这个语素可以是并置语素。
    /// 
    /// 
    /// 排列符号可以在两个地方出现，一个是子层，另一个是属性位置。当排列符号出现
    /// 在属性位置，由于并置被视作一体，所以在并置中的任何一个语素含有“排列符号”，其他语素都可以
    /// 含有排列子层。
    /// 
    /// 当排列符号出现在子层，则只有当前子层具有排列特性。
    /// 
    /// 由于属性可以继承，所以当定义关联到一个父定义上的时候，通常都会集成得到“排列符号”。
    /// 定义关联指的是继承或者实例化。
    /// 
    /// 所以，还可以使用如下形式定义对象或者类。
    /// 
    /// ["car"]["object"][
    /// 
    /// ]
    /// 因为object作为被关联定义一定具有排列符号。（若object不具有排列符号，那么object很可能是一个方法的
    /// 名称，由此car也必须是一个方法的名称，除非定义排列符号。然而如果object不具有排列符号而car具有排列
    /// 符号，那么object的方法将仅作为构造方法被引入car的定义域中）。
    /// 
    /// 如何区分“一个”还是“一类”？
    /// 
    /// 出现添加性的信息的时候，为一类，否则为一个！
    /// 排列符号可以出现，然而是否真的出现了排列则决定了是“类”还是“个”。
    /// 
    /// 字段的初始化是一个方法，除字段本身具有排列符号之外，初始化方法所在的子层仅有初始化方法而没有
    /// 其他成员，所以不“构成”排列符号。所以字段，即便包括初始化方法也只是“个”而不是“类”。
    /// 
    /// 属性Property的情况特殊一些，获取器和设置器是两个排列在子层中的方法，这使得子层“构成”排列
    /// 符号，如何处理这种情况？
    /// 
    /// 不处理，留在高层处理。因为在这个阶段无法定义这样的语法结构，因为这个阶段除了并置和排列，
    /// 没有其他元素可以使用！
    /// 
    /// 
    /// 
    /// 在方法中定义的参数由于不可能含有排列符号，所以一定是个而不是类。
    /// 在方法中定义的变量由于不可能含有排列符号，所以也是个而不是类。
    /// 
    /// …… 放弃并置中的属性传递！
    /// 只能将属性传递到未知语素上！！！！（需要在实现时具体的考虑）
    /// 
    /// 
    /// 关于对象生成的时机：
    /// 
    ///   由于存在构造语法，所以对象的生成可以由生成语法实现，例如“一个……”即可生成对象，或者“a ……”
    ///   也具有相同的语义。
    /// 
    ///   事物描述本身并不指明共同基类object，虽然这个积累是要在.NET平台上必须遵循的。
    ///   事物描述可以具有很多不同的基类，在语义上，它并不具有单根的性质。
    /// 
    ///   这和类的单根性质并不矛盾，因为在语义上的非单根完全可以由interface进行表达。
    /// 
    ///   这就出现了如何区分类和接口的问题。
    /// 
    ///   遵照惯例，我们将完全不含有实现的类定义为接口；实现不完全的定义为抽象类；实现完全的则定义为类。
    /// 
    ///   由于实现不完全，抽象类无法实例化，所以抽象类不可能成为对应的字段。
    /// 
    /// 
    /// 
    /// 
    /// 总结：
    /// 
    /// 是什么？
    /// 
    /// 概念语言是用来描述概念的语言。
    /// 
    /// 所谓概念是指人类（或者其他人类同构智能体）对其环境及其中特定事物或者过程的理解。
    /// 
    /// 所谓理解即人类（或者其他人类同构智能体）对源自于环境及其中事物或者过程的信号实现结构化归纳的结果。
    /// 仅考虑语言系统相关问题，则假定任何理解均可以正确的表达为语言可描述的概念。（多数形象理解并不能
    /// 很好的转化为对应的语言表达，但这对于以计算机为基础的人类同构智能体并不是最重要的问题。此外需要
    /// 指出，图灵和诺依曼体系结构都不是真正的人类同构智能体。）
    /// 
    /// 
    /// 
    /// 要用到的概念：
    /// 
    /// 模式：    概念语言使用模式作为对事物或者过程之间（描述）关系的分析模型。为了实现仅用
    ///           语言又能够无限扩展的对事物或者过程的理解（我们无法使用形象等方式）的描述，
    ///           我们就必须假定系统不能存在任何语言形式的先验描述，即我们不能定义“关键字”。
    ///           然而，我们仍然要面对诸如识别事物和过程等基本概念类型的问题，所以，我们引入
    ///           模式作为识别类树结构语言描述的基本方法。所谓模式在这里是指众多概念点之间构成
    ///           的结构关系所符合的特定形式。显然，我们不可能在先得知概念含义的前提下分析
    ///           待描述的概念，我们仅可以根据特定的概念点的组合（并置或者内置以及并置内置的
    ///           复杂混合）来分析并理解一个待知的概念。为了正确的分析和理解待知概念，我们
    ///           将使用特定的模式区分一个组合所代表的概念类型。当然，我们可以通过已知来辅助
    ///           了解这一概念的类型，但是当系统建立之初，我们仅能够凭借先定的模式对概念进行
    ///           分析；不仅如此，随后的任何新加概念以及自定义模式都需要对先定模式的引用。
    ///           为了使得概念语言脱离语法的束缚，我们必然使用模式；幸好我们可以将模式尽可能
    ///           的设定到接近自然语言模式的程度。
    /// 
    /// 
    /// 描述：    概念语言本身是一种描述语言。通过模式识别，我们可以基本上判定一个给定的模式
    ///           是用来描述事物的（事物描述）还是用来描述过程的（过程描述）。
    ///           为了和先有程序设计语言相适应，事物描述将最终映射为类或者字段，而过程描述将
    ///           最终映射为方法或者函数。
    /// 
    /// 事物：    在语言上表现为“名词”。在人类认知中，可以是语言的、形象的等对某一事物的理解。
    ///           我们可以通过已知事物的组合或者特定模式实现对指定事物的描述。
    /// 过程：    在语言上表现为“动词”。在人类认知中，可以是语言的、形象的等对某一过程的理解。
    ///           我们可以通过已知过程的并置实现对指定过程的描述。
    /// 
    /// 
    /// 已知：    系统中已经存在的概念，可以通过并置的方式将这一概念的属性传递给待知。
    /// 待知：    需要进行构造并添加到系统中的概念，可以被已知并置或者使用模式识别单独构造。
    /// 概念点：  已知或者待知都是概念点。虽然任何概念点本身不能够形成概念，但是概念点的联系可以生成任意复杂的概念。
    /// 
    /// 并置：    并置以顺序表（List）的形式将两个或者两个以上的概念点相关联。这种关联可以将已知的属性传递给待知。
    /// 内置：    内置以子节点表（TreeNode）的形式将一系列并列的（并置得到的复合）概念点归并到同一概念点。
    ///           一般使用并置表达对事物而不是过程的描述。
    /// 省略：    使用省略表达对事物的认知尚未完全，而不使用省略表达过程的终结。
    ///           由于过程的有序性，使用并置（而不是内置）将是表达过程的更为合适的方式。
    ///           虽然如此，区别过程描述和事物表述并不能够仅以是否是并置来区别，这是因为内置中仅含有一个
    ///           并置的事物描述是完全成立的。所以，为了区别过程描述和事物描述，应使用省略[...]来显式
    ///           的标定一个事物描述而不是过程描述。
    /// 
    /// 
    /// 
    /// 问题和解答：
    /// 
    /// 为什么存在省略？
    /// 
    /// 概念语言作为一种语言，其基础结构必然是人类同构智能体。对于人类而言，语言系统仅是人类智能体系
    /// 的一个部分。语言系统不可能完全的无障碍的表达所有智能部分可以理解的所有概念 － 事实上，人类需要
    /// 所有智能部分的协同工作才能够实现对事物的无障碍的理解和表达。不难明白，语言系统表述和理解事物
    /// 和动作是存在困难的，这正如逻辑系统表述和理解复杂图像一样难以实现，然而人类在语言中使用两个最为
    /// 基本的分类，这就是名词和动词。名词表达事物而动词表达动作或者过程。若仅以语言系统表达或者区分
    /// 事物和过程，对于人类来说，并不存在问题 － 只要使用特定的词性和正确的上下文场景或者某些语言中
    /// 的分词形式。然而，对于其他人类同构智能体或者其他无分词形式的语言来说，区分事物和过程将仅能够
    /// 从上下文中获得。
    /// 
    /// 若仅考虑计算机为基础的人类同构智能体，那么区分事物和过程将仅可能以“关键字”形式实现。
    /// 这是因为计算机为基础的人类同构智能体并不具有所谓的“运动中枢”，则它不可能对特定动作、行为、
    /// 以及由动作行为甚至包括视觉感知的运动等提供“关于动作或过程的调制信号”，由此这种系统即便
    /// 可以实现语言描述过程，也不可能真正的以无“关键字”的形式来区分事物和过程。
    /// 
    /// 省略，事实上起到“关键字”的作用，只是它的出现更具有意义，也更为符合自然语言的表达方式。
    /// 
    /// 
    /// 基本模式：
    /// 
    /// 0. 存在展示
    ///    []
    ///    存在展示标识某个概念的存在性。
    ///    存在展示并不指明任何关系，概念是孤立的，仅用于随后对它的引用。
    /// 
    ///    一般可以使用存在展示表达类似“形容词”等词性，内置的存在展示
    ///    可能被直接映射为枚举。
    /// 
    /// 1. 基本并置
    /// 
    ///    [][] ... （请区别[...]和...。前者是省略，后者是可能的重复）
    /// 
    ///    基本并置指出概念之间存在（较强的）联系。
    /// 
    ///    基本并置可以由两个或者两个以上的概念点并立而成。
    ///    其内部结构为一链表。
    /// 
    ///    对于事物描述和过程描述，基本并置的含义可能不同（可以通过省略来区分事物和过程）。
    /// 
    ///    多数情况下，我们讨论的是事物描述的并置：
    /// 
    ///    对于指定的待知事物，若待知事物被已知事物并置，则可以判定待知事物具有已知事物的某种属性。
    ///    待知事物将会首先集成已知事物的所有属性，并在这个基础上进行扩展。
    ///    待知事物可能会丢弃某些已知事物的属性，这是由于不使用这些属性造成的。
    ///    这种并置关系通常被映射为“派生”或者“实现”（对于接口）。待知事物将被映射为类（包括抽象类）
    ///    或者接口，视待知事物的“基类”以及待知事物的“成员”而定 － 必要的时候考虑待知事物被引用的
    ///    情况。
    /// 
    ///    当并置的数量为2，即只有二元关系的时候，并置的顺序是可以忽略的。然而当并置数量大于2的时候，
    ///    需要考虑并置中各个概念点的重要程度。可以考虑使用2的指数或者二叉树的形式进行并置关系分析。
    /// 
    ///    我们也可以实现对动作（表现为动词以及动宾短语）的并置：
    /// 
    ///    当我们描述过程的时候（用省略来区分事物和过程），我们需要将动词进行并置。
    ///    此时，动词或者动宾短语的并置意味着过程的连续性。无论并置数量是否为2（如果并置数量为1，
    ///    也就是没有并置时同样成立），并置都表达连续性，所以顺序必须考虑。
    /// 
    ///    虽然，我们可以为过程定义签名，但是过程签名本质上仍然是事物描述而不是过程描述，所以
    ///    可以保证过程描述一定是过程的并置。
    /// 
    ///    并置的本意是非常紧密的关联，如果关联仅为“的”或者“of”请使用内置。
    /// 
    /// 2. 基本内置
    /// 
    ///    [[],[],[]...]
    ///    
    ///    基本内置指事物的组成关系。
    ///    基本内置的内部标识为树的子树列表。
    /// 
    ///    基本内置仅用于事物的组成描述而不表述过程。
    /// 
    ///    
    /// 
    /// 
    /// 更改：
    /// 
    ///   使用和省略并置来表达过程。省略本身表达一个空过程。
    /// 
    ///   内置省略意味着事物描述。
    ///   所以，一个方法定义也是一个事物描述。
    /// 
    ///   为了区别方法定义和事物描述，应考虑方法签名部分，方法签名部分应含有一个内置的省略 － 不可能存在两个
    ///   方法描述的并置。
    /// 
    ///   [影响的事物][ [[方法签名1],[方法签名2]...][方法体] ]
    /// 
    ///   若不影响任何事物，则可以表达为：
    /// 
    ///   [[方法签名1],[方法签名2]...][方法体]
    /// 
    ///   其中，方法体可以定义为：
    /// 
    ///   [方法体] = [[][][...]] 
    ///   
    ///   即内置一个“省略并置”（延续并置）。
    /// 
    /// 
    ///   这意味着过程（用省略并置）比事物更基本 － 过程构成了事物。
    /// 
    ///   在这个方案中，由于省略只和过程并置，所以不需要将省略添加到事物描述中！
    /// 
    /// 省略从排列符号改为延续符号。
    /// 
    /// [[][][...]] 称为一个过程块。过程块中“仅可以”含有过程块。
    /// 
    /// 如：
    /// 
    /// [[][[][...]][...]]
    /// 
    /// 过程块可以是一个调用或者一个句式。
    /// 
    /// [[if][xxx][then][xxx]][...]
    /// 
    /// 事实上，过程块和单独的过程等价，只是过程块可以给出一个语法层次。
    /// 
    /// [x] = [[x]][...]
    /// 
    /// 相当于加括号。
    /// 
    /// 最困难的是，如果所有过程概念点都不加括号，那么很可能出现歧义。
    /// 
    /// 如果连最外层的括号也没有，那么过程块不成立。
    /// 
    /// 可以省略加括号过程中的延续符号[...]但是仍然要保证没有排列（也就是没有逗号分割的子层），
    /// 除非支持“并行过程”。
    /// 
    /// 因为最外层的延续符号[...]存在，所以内部的确可以实现“并行过程”。作为原则，延续符号并置
    /// 的内部不可以是排列。
    /// 
    /// 
    /// 
    /// </summary>
    public virtual Compilation_Unit Define(
    [SyntaxSlot("using_directive", SlotType = SyntaxSlotType.SyntaxOptionalRepeatableType)] ConceptPoint using_directives,
    [SyntaxSlot("namespace_member_declarations", SlotType = SyntaxSlotType.SyntaxOptionalRepeatableType)] ConceptPoint namespace_member_declarations,
    [SyntaxSlot("attribute_sections", SlotType = SyntaxSlotType.SyntaxOptionalRepeatableType)] ConceptPoint attribute_sections
      )
    {
      return this;
    }
  }
  #endregion
}
